#include "my_array.h"

using namespace std;

/*
My_Array::init_my_array
    My_Array:: 作用域运算符, 俗称 四饼
    明确告知编译器，当前实现的函数是 My_Array 结构体中的
    成员函数。
*/
void My_Array::init_my_array()
{
    /*
    申请存储 int 类型数据的数组空间
    */
    array_data = new int[DEFAULT_CAPACITY];
    memset(array_data, 0, DEFAULT_CAPACITY);

    /*
    capacity 对应底层数组的容量，赋值为默认容量 DEFAULT_CAPACITY
    */
    capacity = DEFAULT_CAPACITY;
    /*
    当前 size 有效元素个数为 0
    */
    size = 0;
}

void My_Array::add_element(int ele)
{
    array_data[size++] = ele;
}

void My_Array::show()
{
    // 当前数组有效元素为 0 ，没有元素
    if (0 == size)
    {
        cout << "[]" << endl;
    }

    cout << '[';

    for (int i = 0; i < size - 1; i++)
    {
        cout << array_data[i] << ", ";
    }

    cout << array_data[size - 1] << ']' << endl;
}

int My_Array::min_value()
{
    /*
    结构体中的成员函数可以直接使用结构体内部的成员变量
        array_data 结构体中的数据数组
        size 是当前数组的有效元素个数
    */
    int min_value = array_data[0];

    for (int i = 1; i < size; i++)
    {
        if (array_data[i] < min_value)
        {
            min_value = array_data[i];
        }
    }

    return min_value;
}

int My_Array::max_value()
{
    /*
    结构体中的成员函数可以直接使用结构体内部的成员变量
        array_data 结构体中的数据数组
        size 是当前数组的有效元素个数
    */
    int max_value = array_data[0];

    for (int i = 1; i < size; i++)
    {
        if (array_data[i] > max_value)
        {
            max_value = array_data[i];
        }
    }

    return max_value;
}

double My_Array::avg_value()
{
    int total_value = 0;

    for (int i = 0; i < size; i++)
    {
        total_value += array_data[i];
    }

    return total_value / (size * 1.0);
}

int My_Array ::find(int value)
{
    for(int i = 0; i < size; i++)
    {
        if(array_data[i] == value)
        {
           return i; 
        }
    }
    return -1;
}

int My_Array ::rfind(int value)
{
    int index = -1;
    for(int i = 0; i < size; i++)
    {
        if(array_data[i] == value)
        {
            index = i; 
        }
    }
    return index;
}

void My_Array ::add_element(int index, int ele)
{
    if(index > size || index < 0)
    {
        cout << "该位置不能添加元素" << endl;
    }
    else
    {
        array_data[size++] = ele;

    for(int i = size; i >= index; i--)
    {
        array_data[i] = array_data[i - 1];
    }
    array_data[index] = ele;
    }
}

void My_Array::add_all(My_Array &ma)
{
    // 检查是否需要扩容
    if (size + ma.size > capacity)
    {
        // 扩容逻辑
        int new_capacity = capacity + ma.size;
        int *new_array = new int[new_capacity];
        memcpy(new_array, array_data, size * sizeof(int));
        delete[] array_data;
        array_data = new_array;
        capacity = new_capacity;
    }

    // 将 ma 的元素添加到当前数组末尾
    for (int i = 0; i < ma.size; i++)
    {
        array_data[size++] = ma.array_data[i];
    }
    for (int i = 0; i < ma.size; i++)
    {
        cout << array_data[i] << " " ;
    }
    

}

void My_Array::add_all(int index, My_Array &ma)
{
    if (index < 0 || index > size)
    {
        cout << "下标越界，无法添加元素" << endl;
        return;
    }

    // 检查是否需要扩容
    if (size + ma.size > capacity)
    {
        // 扩容逻辑
        int new_capacity = capacity + ma.size;
        int *new_array = new int[new_capacity];
        memcpy(new_array, array_data, size * sizeof(int));
        delete[] array_data;
        array_data = new_array;
        capacity = new_capacity;
    }

    // 将原数组从 index 开始的元素向后移动 ma.size 个位置
    for (int i = size - 1; i >= index; i--)
    {
        array_data[i + ma.size] = array_data[i];
    }

    // 将 ma 的元素插入到 index 位置
    for (int i = 0; i < ma.size; i++)
    {
        array_data[index + i] = ma.array_data[i];
    }

    size += ma.size;
}

int My_Array::remove(int index)
{
    int ret = array_data[index];

    if(index >= size)
    {
        return 0;
    }
    else
    {
        for(int i = index; i < size - 1; i++)
        {
            array_data[i] = array_data[i + 1];
        }
        size -= 1;
        return ret;
    }
}

void My_Array::remove_all(int ele)
{
    int count = 0;
    for(int i = 0; i < size; i++)
    {
        if(array_data[i] == ele)
        {
           for(int j = i; j < size; j++)
           {
            array_data[j] = array_data[j + 1];
           }
           i--;
           count++;
        }
    }
    size -= count;
}

void My_Array::remove_all(My_Array &ma)
{
// 遍历 ma 中的元素，逐个删除
for (int i = 0; i < ma.size; i++)
{
    remove_all(ma.array_data[i]);
}
}

void My_Array::retain_all(My_Array &ma)
{
    // 创建一个临时数组，用于存储交集
    int *temp_array = new int[size];
    int temp_size = 0;

    // 遍历当前数组，检查元素是否在 ma 中
    for (int i = 0; i < size; i++)
    {
        if (ma.find(array_data[i]) != -1)
        {
            temp_array[temp_size++] = array_data[i];
        }
    }

    // 释放原数组内存，替换为临时数组
    delete[] array_data;
    array_data = temp_array;
    size = temp_size;
}
void My_Array::remove_all(int begin, int end)
{
    int count = 0;
    if(begin >= end || begin < 0 || begin > size - 1)
    {
        cout << "您输入的初始或终止下标不合法~~~" << endl;
    }
    for(int i = begin; i < (size > begin ? begin : size); i++)
    {
        array_data[i] = 0;

        if(0 == array_data[i])
        {
           for(int j = i; j < size; j++)
           {
            array_data[j] = array_data[j + 1];
           }
           i--;
           count++;
        }
    }
    size -=count;
}
    

void My_Array::destroy()
{
    delete[] array_data;
}
void My_Array::replace(int index, int new_value)
{
    if (index < 0 || index >= size)
    {
        cout << "下标越界，无法替换元素" << endl;
        return;
    }

    array_data[index] = new_value;
}

void My_Array::replace_all(int old_value, int new_value)
{
    for (int i = 0; i < size; i++)
    {
        if (array_data[i] == old_value)
        {
            array_data[i] = new_value;
        }
    }   
}

void My_Array::replace_all(int pos, int count, My_Array &ma)
{
    if (pos < 0 || pos >= size || count < 0 || pos + count > size)
    {
        cout << "参数不合法，无法替换元素" << endl;
        return;
    }

    // 检查是否需要扩容
    if (size - count + ma.size > capacity)
    {
        // 扩容逻辑
        int new_capacity = size - count + ma.size;
        int *new_array = new int[new_capacity];
        memcpy(new_array, array_data, size * sizeof(int));
        delete[] array_data;
        array_data = new_array;
        capacity = new_capacity;
    }

    // 将原数组从 pos + count 开始的元素向后移动 ma.size - count 个位置
    for (int i = size - 1; i >= pos + count; i--)
    {
        array_data[i + ma.size - count] = array_data[i];
    }

    // 将 ma 的元素插入到 pos 位置
    for (int i = 0; i < ma.size; i++)
    {
        array_data[pos + i] = ma.array_data[i];
    }

    size = size - count + ma.size;
}

void My_Array::reveser()
{
    for (int i = 0; i < size / 2; i++)
    {
        int temp = array_data[i];
        array_data[i] = array_data[size - 1 - i];
        array_data[size - 1 - i] = temp;
    }
}

int My_Array::at(int index)
{
    if (index < 0 || index >= size)
    {
        cout << "下标越界，无法获取元素" << endl;
        return -1; // 返回 -1 表示错误
    }

    return array_data[index];
}

My_Array &My_Array::sub_array(int pos, int count)
{
    if (pos < 0 || pos >= size || count < 0 || pos + count > size)
    {
        cout << "参数不合法，无法获取子数组" << endl;
        return *this; // 返回当前对象
    }

    // 创建新的 My_Array 对象
    My_Array *sub = new My_Array();
    sub->init_my_array();

    // 复制子数组内容
    for (int i = pos; i < pos + count; i++)
    {
        sub->add_element(array_data[i]);
    }

    return *sub;
}

void My_Array::sort_desc()
{
    // 降序排序
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - 1 - i; j++)
        {
            if (array_data[j] < array_data[j + 1])
            {
                int temp = array_data[j];
                array_data[j] = array_data[j + 1];
                array_data[j + 1] = temp;
            }
        }
    }
}

void My_Array::sort_asc()
{
    // 升序排序
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - 1 - i; j++)
        {
            if (array_data[j] > array_data[j + 1])
            {
                int temp = array_data[j];
                array_data[j] = array_data[j + 1];
                array_data[j + 1] = temp;
            }
        }
    }
}